Motivation
These changes attempt to stabilize Kokkos Comm's public API for "handles". In particular, it aims at:

• Settling on a "correct" name for these objects that wrap a library-specific communicator handle and a Kokkos execution space
• Removing any backend-dependent interfaces from their public API
• Expanding the capabilities of these objects
• Defining a set of mandatory supported operations
• Unifying implementation strategies in the backend specializations (as much as possible)
• Bringing the documentation up-to-date

Implementation notes

Unified interface across backends:
The central design constraint was that Communicator<Ex, MpiSpace> and Communicator<Ex, NcclSpace> must expose identical public interfaces, so that code written against the abstraction does not need to branch on the backend.

Factory functions instead of constructors:
Construction is intentionally not possible via public constructors because there are multiple ways to create communicators. Static "factory" member functions (from_raw, duplicate_from_raw, split_from_raw) were chosen for three reasons:

1. They have meaningful names that make construction intent explicit at the call site;
2. They can return std::optional to force callers to handle failure without exceptions; and
3. They make it impossible to accidentally construct a Communicator in an invalid state.

A builder pattern was considered but rejected — with only three construction modes and minimal configuration, a builder would add object lifetime complexity for little real benefit, and in the long run, could promote backend-specific setter methods that would gradually erode the generic interface.

Non-owning from_raw:
from_raw never takes ownership of the raw handle it is given. If a user created a raw communicator, they opted out of the abstraction layer and retain responsibility for its lifetime. Allowing optional ownership transfer would reintroduce a boolean parameter at the call site and recreate the exact class of double-free and leak bugs the design is meant to prevent. The ownership table is simple and memorable: only duplicate and split produce owned communicators, because only they allocate a new backend handle internally.

Explicit copies, move-only by default:
The copy constructor and copy assignment operator are deleted. Duplicating a communicator is an explicit MPI/NCCL operation with observable side effects and a potential for failure; silently copying a Communicator as though it were a value type would hide that cost entirely. Users who need a copy call duplicate(), which makes the intent and the cost visible. Move semantics are implemented manually rather than defaulted: the move constructor uses std::exchange to null out the source handle and set owned_ to false, ensuring the moved-from object's destructor is always a no-op and preventing double-free.